﻿
/*
# include <stdlib.h>

int globalVar = 1; 
static int staticGlobalVar = 1; // 比globalVar还要先销毁,同一个文件下后定义的先析构
// 全局变量存在 数据段（静态区）但是 链接方式和静态变量不同，全部文件下都能知道globalvar的存在
// 但是staticGlobalVar只在当前文件(test.cpp)下存在
// 注意： 多个文件的话，那个全局变量先析构是不确定的
void Test()
{
	static int staticVar = 1; // 作用域只在Test函数中，函数栈帧销毁后，也跟着销毁了
	int localVar = 1;

	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	const char* pChar3 = "abcd";

	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);


	free(ptr1);
	free(ptr3);
}

/*
1. 选择题：
选项 : A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
globalVar在哪里？__C__   staticGlobalVar在哪里？__C__
staticVar在哪里？__C__   localVar在哪里？__A__
num1 在哪里？__A__

char2在哪里？__A__ *char2在哪里？_A__ // *char拿的是数组的首元素,整个数组都位于栈区，首元素自然也在栈区
pChar3在哪里？__A__ *pChar3在哪里？__D__ //*pChar3 是常量字符串的首元素，pChar3指向常量区的常量字符串
ptr1在哪里？__A__ *ptr1在哪里？__B__ // ptr1是在栈区的一个指向堆区数组的指针

2. 填空题：
sizeof(num1) = __40__;
sizeof(char2) = __5__;      strlen(char2) = __4__; // 5是因为还有一个\0
sizeof(pChar3) = __8/4__;    strlen(pChar3) = __4__;// pChar3是指针变量
sizeof(ptr1) = __8/4__; // ptr1也是指针变量

3. sizeof 和 strlen 区别？
sizeof就是去算所占空间的大小
strlen 就是读取一个字符串的长度，遇到\0就会停下来
*/

/*
// C++内存管理方式
int main()
{
	// c++提供new操作符来动态开辟空间
	int* p1 = new int; // 开辟int类型的空间
	int* p2 = new int[10]; // 开辟10个int类型的空间
	int* p3 = new int(10); // 开辟一个int类型的空间，并初始化成10

	// c++提供delete操作符来释放空间
	delete p1;
	delete[] p2; // 数组的话要记得加 []
	delete p3;

	return 0;
}
*/

/*
// 既然有了malloc 和 free了。那new和 delete有什么意义呢？
// 1.对于内置类型来说，new 和 delete跟malloc和free起到的作用是一样的。
// 2.但是对于自定义的类型来说，new和delete的意义就出来了
// malloc 只会申请空间， new则会申请空间 + 调用构造函数初始化
// free 只会释放空间， delete则会 调用析构函数 + 释放空间 [注意是先析构再释放空间]

# include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A()" << endl;
	}

	~A()
	{
		cout << "~A" << endl;
	}

private:
	int _a;
};

int main()
{
	// 为自定义类型申请空间下 new和malloc的区别
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A; // 申请空间 + 调用默认构造函数

	// 为自定义类型对象释放空间下  delete 和 free的区别

	free(p1); // 释放空间
	delete p2; // 调用析构函数 + 释放空间

	return 0;
}
*/

/*
//new和delete的直观应用
# include<stdlib.h>
# include<iostream>
using namespace std;

typedef struct ListNode
{
	int _val;
	struct ListNode* _next; // 兼容C语言的用法
	ListNode* _prev;// cpp专有用法，因为在c++中struct可以看做一个类,唯一区别就是默认的访问限定符不同

	ListNode(int val = 0)
		:_val(val)
		,_next(nullptr)
		,_prev(nullptr)
	{
	}

	~ListNode()
	{
		cout << "~ListNode" << endl;
	}
}ListNode;

int main()
{
	// 在之前使用C语言来实现链表的时候，我们每次申请节点都要malloc，因此我们会写一个BuyNode函数
	// 并且函数中，还要编写初始化的代码，但是对于new 和 delete来说，就不用这么麻烦了。
	ListNode* node1 = (ListNode*)malloc(sizeof(ListNode));
	node1->_val = 0;
	node1->_next = nullptr;
	node1->_prev = nullptr;

	ListNode* node2 = new ListNode;

	ListNode* node3 = new ListNode(10);

	// 在C语言中会调用Destroy之类的函数来销毁我们申请的节点
	free(node1); // Destory函数中是free函数释放空间
	
	// c++中使用delete不仅会释放空间，在释放空间之前还会调研析构函数
	delete node2;
	delete node3;

	return 0;
}
*/

